```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>父线程和子线程之间如何传递数据 | 技术小馆</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            background-color: #f9fafb;
            color: #374151;
            line-height: 1.75;
        }
        .noto-serif {
            font-family: 'Noto Serif SC', serif;
        }
        .hero-bg {
            background: linear-gradient(135deg, #4f46e5 0%, #7c3aed 100%);
        }
        .gradient-text {
            background: linear-gradient(90deg, #4f46e5, #7c3aed);
            -webkit-background-clip: text;
            background-clip: text;
            color: transparent;
        }
        .card {
            transition: transform 0.3s ease, box-shadow 0.3s ease;
        }
        .card:hover {
            transform: translateY(-5px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        .code-block {
            background-color: #1e293b;
            color: #f8fafc;
            border-radius: 0.5rem;
        }
        .section-divider {
            height: 1px;
            background: linear-gradient(90deg, rgba(79,70,229,0) 0%, rgba(79,70,229,0.5) 50%, rgba(79,70,229,0) 100%);
        }
        .highlight-box {
            border-left: 4px solid #4f46e5;
            background-color: #f5f3ff;
        }
        .mermaid {
            background-color: white;
            border-radius: 0.5rem;
            padding: 1.5rem;
            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
        }
        .list-item {
            position: relative;
            padding-left: 1.5rem;
        }
        .list-item:before {
            content: "";
            position: absolute;
            left: 0;
            top: 0.75rem;
            width: 0.5rem;
            height: 0.5rem;
            border-radius: 50%;
            background-color: #7c3aed;
        }
    </style>
</head>
<body class="antialiased">
    <!-- Hero Section -->
    <header class="hero-bg text-white py-20 px-4 sm:px-6 lg:px-8">
        <div class="max-w-4xl mx-auto text-center">
            <h1 class="noto-serif text-4xl sm:text-5xl lg:text-6xl font-bold mb-6 leading-tight">
                父线程与子线程之间的<span class="gradient-text">数据传递</span>艺术
            </h1>
            <p class="text-xl sm:text-2xl text-indigo-100 max-w-3xl mx-auto mb-8">
                探索现代多线程编程中高效、安全的数据共享与通信机制
            </p>
            <div class="flex justify-center space-x-4">
                <a href="#concepts" class="px-6 py-3 bg-white text-indigo-600 font-medium rounded-full hover:bg-indigo-50 transition duration-300">
                    <i class="fas fa-book-open mr-2"></i>核心概念
                </a>
                <a href="#methods" class="px-6 py-3 border-2 border-white text-white font-medium rounded-full hover:bg-white hover:bg-opacity-10 transition duration-300">
                    <i class="fas fa-exchange-alt mr-2"></i>数据传递方法
                </a>
            </div>
        </div>
    </header>

    <!-- Main Content -->
    <main class="max-w-5xl mx-auto px-4 sm:px-6 lg:px-8 py-12">
        <!-- Introduction Section -->
        <section class="mb-16">
            <p class="text-lg text-gray-700 mb-8 leading-relaxed">
                在现代的多线程编程中，线程之间的数据传递是一个不可避免的挑战。特别是在父线程与子线程之间，如何有效且安全地共享数据，是我们在设计并发系统时必须考虑的一个重要问题。在Java中，多线程的实现为我们提供了丰富的工具和机制，使得在父线程与子线程之间传递数据变得可行。
            </p>
            <div class="grid md:grid-cols-2 gap-8 mb-12">
                <div class="bg-white rounded-xl shadow-md overflow-hidden card">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1724135838850-92bc4179-eb5c-46ad-86d8-e96b556e9ab3.png" alt="多线程数据传递" class="w-full h-64 object-cover">
                    <div class="p-6">
                        <h3 class="text-xl font-bold mb-2">线程间通信机制</h3>
                        <p class="text-gray-600">多线程环境中数据共享与同步的艺术</p>
                    </div>
                </div>
                <div class="bg-white rounded-xl shadow-md overflow-hidden card">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1724135911006-1361ec53-43c0-494d-8efb-fc1190b715c8.png" alt="线程关系图" class="w-full h-64 object-cover">
                    <div class="p-6">
                        <h3 class="text-xl font-bold mb-2">线程层次结构</h3>
                        <p class="text-gray-600">父线程与子线程的依赖关系与生命周期管理</p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Concepts Section -->
        <section id="concepts" class="mb-16">
            <h2 class="noto-serif text-3xl font-bold mb-8 text-gray-900 flex items-center">
                <span class="gradient-text">父线程与子线程的基本概念</span>
            </h2>
            
            <div class="grid md:grid-cols-2 gap-8 mb-10">
                <div class="highlight-box p-6 rounded-lg">
                    <h3 class="text-xl font-bold mb-4 text-indigo-700 flex items-center">
                        <i class="fas fa-user-friends mr-3"></i>父线程
                    </h3>
                    <p class="text-gray-700">
                        父线程是一个已经存在并且创建了其他线程的线程。在Java中，当一个线程启动另一个线程时，启动的线程被称为父线程，而被启动的线程被称为子线程。父线程拥有控制子线程生命周期的能力，包括启动、暂停、恢复、终止等操作。
                    </p>
                </div>
                <div class="highlight-box p-6 rounded-lg">
                    <h3 class="text-xl font-bold mb-4 text-indigo-700 flex items-center">
                        <i class="fas fa-user mr-3"></i>子线程
                    </h3>
                    <p class="text-gray-700">
                        子线程是由父线程创建并启动的线程。子线程是独立执行的，拥有自己的执行路径，但它与父线程共享相同的内存空间，这意味着子线程可以访问和修改父线程中的共享数据。这种共享的特点也是多线程编程中的一大挑战，因为它引发了数据一致性和线程安全性的问题。
                    </p>
                </div>
            </div>

            <h3 class="text-2xl font-semibold mb-4 text-gray-800 mt-12">1. 父线程与子线程的关系</h3>
            <div class="mb-8">
                <div class="list-item mb-4">
                    <h4 class="text-lg font-medium text-gray-800">线程的层次结构</h4>
                    <p class="text-gray-700 mt-1">
                        在Java中，虽然线程没有严格的父子层次关系（即Java的线程模型没有强制的父子依赖关系），但逻辑上，父线程与子线程的关系往往是依赖性的。子线程的生命周期通常依赖于父线程的控制，并且在某些情况下，父线程会等待子线程完成后再继续执行，这种关系通过<code>Thread.join()</code>方法来实现。
                    </p>
                </div>
                <div class="list-item mb-4">
                    <h4 class="text-lg font-medium text-gray-800">资源共享与竞争</h4>
                    <p class="text-gray-700 mt-1">
                        父线程与子线程运行在相同的进程中，因此它们共享相同的堆内存空间。共享数据可能导致数据竞争问题，比如多个线程同时读写同一变量可能会引发不可预期的结果。这也是Java多线程编程中需要特别关注的问题之一。
                    </p>
                </div>
            </div>

            <h3 class="text-2xl font-semibold mb-4 text-gray-800">2. 父线程与子线程的生命周期</h3>
            <div class="mb-8">
                <div class="list-item mb-4">
                    <h4 class="text-lg font-medium text-gray-800">生命周期阶段</h4>
                    <p class="text-gray-700 mt-1">
                        线程的生命周期可以分为五个阶段：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和终止（Terminated）。父线程创建子线程后，子线程进入就绪状态，等待CPU调度。当子线程完成它的任务后，进入终止状态。父线程可以通过<code>join()</code>方法等待子线程完成任务，也可以在子线程执行期间执行其他操作。
                    </p>
                </div>
                <div class="list-item">
                    <h4 class="text-lg font-medium text-gray-800">线程组（ThreadGroup）</h4>
                    <p class="text-gray-700 mt-1">
                        在Java中，线程组可以用来组织和管理一组线程。虽然线程组可以包含父线程和它创建的子线程，但在现代Java开发中，线程组的使用已经不再推荐，更多的是使用<code>Executor</code>框架来管理线程的生命周期和执行。
                    </p>
                </div>
            </div>

            <h3 class="text-2xl font-semibold mb-4 text-gray-800">3. 父线程与子线程的数据传递</h3>
            <p class="text-gray-700 mb-8">
                父线程与子线程之间的数据传递是多线程编程中的一个重要主题。通过共享内存、<code>ThreadLocal</code>变量、以及更高级的并发工具，如<code>Future</code>、<code>Callable</code>等，父线程可以将数据传递给子线程，或者从子线程中获取执行结果。
            </p>
            
            <div class="mermaid mb-12">
                graph TD
                    A[父线程] -->|创建| B[子线程]
                    A -->|共享内存| C[共享数据]
                    B -->|访问| C
                    A -->|ThreadLocal| D[线程局部变量]
                    B -->|独立访问| D
                    A -->|Future/Callable| E[异步结果]
                    B -->|返回| E
            </div>
        </section>

        <div class="section-divider my-12"></div>

        <!-- Data Transfer Methods Section -->
        <section id="methods" class="mb-16">
            <h2 class="noto-serif text-3xl font-bold mb-8 text-gray-900">
                <span class="gradient-text">数据传递的基本方法</span>
            </h2>
            <p class="text-lg text-gray-700 mb-10">
                父线程和子线程之间的数据传递方式有很多，选择合适的方法取决于具体的应用场景和需求。共享内存适用于需要快速、直接的数据传递，但必须考虑线程安全问题。<code>ThreadLocal</code>适用于线程独立的数据，<code>Callable</code>和<code>Future</code>则适用于需要获取计算结果的场景。<code>Concurrent</code>数据结构和<code>Executor</code>框架提供了更高效、更安全的线程管理和数据传递机制。
            </p>
            
            <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1724135961910-9f1ebddc-05e0-43fb-b36b-3f7d49397ea8.png" alt="数据传递方法" class="w-full rounded-xl shadow-md mb-12">

            <div class="grid gap-8">
                <!-- Method 1 -->
                <div class="card bg-white p-6 rounded-xl shadow-md">
                    <div class="flex items-start">
                        <div class="bg-indigo-100 p-3 rounded-lg mr-4 flex-shrink-0">
                            <i class="fas fa-memory text-indigo-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-bold mb-3 text-gray-800">1. 共享内存</h3>
                            <p class="text-gray-700 mb-4">
                                共享内存是线程间数据传递的最基本方法。父线程和子线程通过访问共享的对象或变量来进行数据传递。需要注意的是，这种方法必须确保线程安全，以防止数据竞争和不一致性。
                            </p>
                            <div class="grid md:grid-cols-2 gap-4">
                                <div>
                                    <h4 class="font-medium text-gray-800 mb-2 flex items-center">
                                        <i class="fas fa-shield-alt text-indigo-500 mr-2"></i>线程安全性
                                    </h4>
                                    <p class="text-gray-600 text-sm">
                                        为了保证数据一致性，必须使用同步机制（如<code>synchronized</code>关键字或<code>ReentrantLock</code>类）来保护对共享数据的访问。否则，多个线程可能会同时修改共享数据，导致不可预测的结果。
                                    </p>
                                </div>
                                <div>
                                    <h4 class="font-medium text-gray-800 mb-2 flex items-center">
                                        <i class="fas fa-eye text-indigo-500 mr-2"></i>可见性
                                    </h4>
                                    <p class="text-gray-600 text-sm">
                                        使用<code>volatile</code>关键字可以确保线程对变量的修改对其他线程立即可见，但<code>volatile</code>仅适用于简单数据类型或引用，不能解决复杂的数据同步问题。
                                    </p>
                                </div>
                            </div>
                        </div>
                    </div>
                </div>

                <!-- Method 2 -->
                <div class="card bg-white p-6 rounded-xl shadow-md">
                    <div class="flex items-start">
                        <div class="bg-indigo-100 p-3 rounded-lg mr-4 flex-shrink-0">
                            <i class="fas fa-user-shield text-indigo-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-bold mb-3 text-gray-800">2. ThreadLocal</h3>
                            <p class="text-gray-700 mb-4">
                                <code>ThreadLocal</code>提供了每个线程独立的变量副本。每个线程通过<code>ThreadLocal</code>对象可以获得自己的变量副本，而不会与其他线程共享。
                            </p>
                            <div class="grid md:grid-cols-2 gap-4">
                                <div>
                                    <h4 class="font-medium text-gray-800 mb-2 flex items-center">
                                        <i class="fas fa-project-diagram text-indigo-500 mr-2"></i>作用域
                                    </h4>
                                    <p class="text-gray-600 text-sm">
                                        <code>ThreadLocal</code>适用于需要线程独立的数据，比如线程上下文信息。每个线程在访问<code>ThreadLocal</code>变量时，都会得到自己线程的副本。
                                    </p>
                                </div>
                                <div>
                                    <h4 class="font-medium text-gray-800 mb-2 flex items-center">
                                        <i class="fas fa-code text-indigo-500 mr-2"></i>使用示例
                                    </h4>
                                    <p class="text-gray-600 text-sm">
                                        <code>ThreadLocal</code>可以用于存储用户会话信息、数据库连接等每个线程需要独立持有的数据。
                                    </p>
                                </div>
                            </div>
                        </div>
                    </div>
                </div>

                <!-- Method 3 -->
                <div class="card bg-white p-6 rounded-xl shadow-md">
                    <div class="flex items-start">
                        <div class="bg-indigo-100 p-3 rounded-lg mr-4 flex-shrink-0">
                            <i class="fas fa-retweet text-indigo-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-bold mb-3 text-gray-800">3. Callable 和 Future</h3>
                            <p class="text-gray-700 mb-4">
                                <code>Callable</code>接口和<code>Future</code>类提供了一种从子线程获取结果的机制。父线程可以通过<code>Future</code>对象获取子线程的执行结果，从而实现数据传递。
                            </p>
                            <div class="grid md:grid-cols-2 gap-4">
                                <div>
                                    <h4 class="font-medium text-gray-800 mb-2 flex items-center">
                                        <i class="fas fa-puzzle-piece text-indigo-500 mr-2"></i>Callable接口
                                    </h4>
                                    <p class="text-gray-600 text-sm">
                                        与<code>Runnable</code>不同，<code>Callable</code>接口的<code>call()</code>方法可以返回结果，并且可以抛出异常。
                                    </p>
                                </div>
                                <div>
                                    <h4 class="font-medium text-gray-800 mb-2 flex items-center">
                                        <i class="fas fa-hourglass-half text-indigo-500 mr-2"></i>Future类
                                    </h4>
                                    <p class="text-gray-600 text-sm">
                                        <code>Future</code>类表示异步计算的结果。通过调用<code>Future.get()</code>方法，父线程可以阻塞并等待子线程的执行结果。
                                    </p>
                                </div>
                            </div>
                            <div class="mt-4 code-block p-4 rounded-lg">
                                <pre class="text-sm text-gray-200"><code>import java.util.concurrent.*;

public class TaskDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        Future&lt;String&gt; future1 = executor.submit(() -&gt; "Task 1 result");
        Future&lt;String&gt; future2 = executor.submit(() -&gt; "Task 2 result");

        System.out.println("Result from Task 1: " + future1.get());
        System.out.println("Result from Task 2: " + future2.get());

        executor.shutdown();
    }
}</code></pre>
                            </div>
                        </div>
                    </div>
                </div>

                <!-- Method 4 -->
                <div class="card bg-white p-6 rounded-xl shadow-md">
                    <div class="flex items-start">
                        <div class="bg-indigo-100 p-3 rounded-lg mr-4 flex-shrink-0">
                            <i class="fas fa-database text-indigo-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-bold mb-3 text-gray-800">4. Concurrent 数据结构</h3>
                            <p class="text-gray-700 mb-4">
                                Java的<code>java.util.concurrent</code>包提供了许多线程安全的数据结构，如<code>ConcurrentHashMap</code>、<code>BlockingQueue</code>等，这些数据结构可以在多个线程之间安全地传递数据。
                            </p>
                            <div class="grid md:grid-cols-2 gap-4">
                                <div>
                                    <h4 class="font-medium text-gray-800 mb-2 flex items-center">
                                        <i class="fas fa-map-marked-alt text-indigo-500 mr-2"></i>ConcurrentHashMap
                                    </h4>
                                    <p class="text-gray-600 text-sm">
                                        适用于高并发环境下的键值对存储，支持高效的并发读写操作。
                                    </p>
                                </div>
                                <div>
                                    <h4 class="font-medium text-gray-800 mb-2 flex items-center">
                                        <i class="fas fa-stream text-indigo-500 mr-2"></i>BlockingQueue
                                    </h4>
                                    <p class="text-gray-600 text-sm">
                                        适用于生产者-消费者模式，实现了线程安全的队列操作，支持阻塞插入和提取操作。
                                    </p>
                                </div>
                            </div>
                        </div>
                    </div>
                </div>

                <!-- Method 5 -->
                <div class="card bg-white p-6 rounded-xl shadow-md">
                    <div class="flex items-start">
                        <div class="bg-indigo-100 p-3 rounded-lg mr-4 flex-shrink-0">
                            <i class="fas fa-tasks text-indigo-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-bold mb-3 text-gray-800">5. Executor框架</h3>
                            <p class="text-gray-700 mb-4">
                                <code>Executor</code>框架提供了一种更高层次的线程管理机制。通过<code>ExecutorService</code>和<code>CompletionService</code>，父线程可以提交任务并获取结果，简化了线程的创建和管理。
                            </p>
                            <div class="grid md:grid-cols-2 gap-4">
                                <div>
                                    <h4 class="font-medium text-gray-800 mb-2 flex items-center">
                                        <i class="fas fa-server text-indigo-500 mr-2"></i>ExecutorService
                                    </h4>
                                    <p class="text-gray-600 text-sm">
                                        提供了任务的提交、执行和结果获取的功能。通过<code>submit()</code>方法提交<code>Callable</code>任务并获取<code>Future</code>对象。
                                    </p>
                                </div>
                                <div>
                                    <h4 class="font-medium text-gray-800 mb-2 flex items-center">
                                        <i class="fas fa-check-circle text-indigo-500 mr-2"></i>CompletionService
                                    </h4>
                                    <p class="text-gray-600 text-sm">
                                        结合了任务的提交和结果获取功能，支持处理异步任务结果。
                                    </p>
                                </div>
                            </div>
                        </div>
                    </div>
                </div>

                <!-- Method 6 -->
                <div class="card bg-white p-6 rounded-xl shadow-md">
                    <div class="flex items-start">
                        <div class="bg-indigo-100 p-3 rounded-lg mr-4 flex-shrink-0">
                            <i class="fas fa-comments text-indigo-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-bold mb-3 text-gray-800">6. 线程间通信</h3>
                            <p class="text-gray-700 mb-4">
                                在一些高级应用场景中，线程间通信（如<code>wait()</code>、<code>notify()</code>机制）可以用于更复杂的数据传递需求。
                            </p>
                            <div class="grid md:grid-cols-2 gap-4">
                                <div>
                                    <h4 class="font-medium text-gray-800 mb-2 flex items-center">
                                        <i class="fas fa-pause-circle text-indigo-500 mr-2"></i>wait()
                                    </h4>
                                    <h4 class="font-medium text-gray-800 mb-2 flex items-center">
                                        <i class="fas fa-bell text-indigo-500 mr-2"></i>notify()
                                    </h4>
                                    <p class="text-gray-600 text-sm">
                                        这些方法用于线程间的协作，允许一个线程等待某个条件，并在条件满足时被其他线程通知。
                                    </p>
                                </div>
                                <div class="code-block p-4 rounded-lg">
                                    <pre class="text-sm text-gray-200"><code>public class WaitNotifyExample {
    public synchronized void doWait() {
        try {
            wait(); // 释放锁并等待
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
    
    public synchronized void doNotify() {
        notify(); // 唤醒一个等待线程
    }
}</code></pre>
                                </div>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <div class="section-divider my-12"></div>

        <!-- Thread Safety Section -->
        <section class="mb-16">
            <h2 class="noto-serif text-3xl font-bold mb-8 text-gray-900">
                <span class="gradient-text">线程安全性问题</span>
            </h2>
            <p class="text-lg text-gray-700 mb-8">
                线程安全性问题在多线程编程中是至关重要的，因为它直接影响程序的稳定性、正确性和性能。在多线程环境中，多个线程可能会同时访问和修改共享数据，从而导致数据不一致、竞态条件（race conditions）、死锁（deadlocks）等问题。
            </p>

            <div class="grid gap-8">
                <!-- Issue 1 -->
                <div class="bg-white p-6 rounded-xl shadow-md">
                    <h3 class="text-2xl font-semibold mb-4 text-indigo-700">1. 竞态条件（Race Conditions）</h3>
                    <p class="text-gray-700 mb-4">
                        竞态条件发生在多个线程并发执行时，它们在没有适当同步的情况下访问和修改共享资源。这可能导致数据的不一致性或不可预测的行为。
                    </p>
                    <div class="code-block p-4 rounded-lg mb-4">
                        <pre class="text-sm text-gray-200"><code>class Counter {
    private int count = 0;

    public void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}</code></pre>
                    </div>
                    <p class="text-gray-600 mb-4">
                        在上述代码中，如果两个线程同时调用<code>increment()</code>方法，可能会导致<code>count</code>的值不符合预期。
                    </p>
                    <div class="highlight-box p-4 rounded-lg">
                        <h4 class="font-medium text-gray-800 mb-2">解决方法：</h4>
                        <div class="grid md:grid-cols-2 gap-4">
                            <div>
                                <p class="text-gray-700">
                                    <strong>同步</strong>：使用<code>synchronized</code>关键字或<code>ReentrantLock</code>类来保护共享资源，确保每次只有一个线程可以访问和修改该资源。
                                </p>
                            </div>
                            <div>
                                <p class="text-gray-700">
                                    <strong>原子操作</strong>：使用<code>AtomicInteger</code>等原子类，这些类提供了线程安全的原子操作。
                                </p>
                            </div>
                        </div>
                    </div>
                </div>

                <!-- Issue 2 -->
                <div class="bg-white p-6 rounded-xl shadow-md">
                    <h3 class="text-2xl font-semibold mb-4 text-indigo-700">2. 数据不一致（Data Inconsistency）</h3>
                    <p class="text-gray-700 mb-4">
                        数据不一致发生在多个线程对共享数据的修改没有得到适当同步，导致某些线程看到的数据与其他线程不同步。
                    </p>
                    <div class="code-block p-4 rounded-lg mb-4">
                        <pre class="text-sm text-gray-200"><code>class SharedResource {
    private volatile boolean flag = false;
    private int data = 0;

    public void writeData() {
        data = 1;
        flag = true;
    }

    public void readData() {
        if (flag) {
            System.out.println(data);
        }
    }
}</code></pre>
                    </div>
                    <p class="text-gray-600 mb-4">
                        在上述示例中，<code>flag</code>的修改可能不会立即对<code>data</code>的读操作可见，可能导致<code>readData()</code>方法读取到不一致的数据。
                    </p>
                    <div class="highlight-box p-4 rounded-lg">
                        <h4 class="font-medium text-gray-800 mb-2">解决方法：</h4>
                        <div class="grid md:grid-cols-2 gap-4">
                            <div>
                                <p class="text-gray-700">
                                    <strong>使用<code>volatile</code>关键字</strong>：确保变量的读写操作对所有线程可见，但<code>volatile</code>仅适用于简单的共享变量。
                                </p>
                            </div>
                            <div>
                                <p class="text-gray-700">
                                    <strong>使用同步机制</strong>：通过<code>synchronized</code>块来确保变量的可见性。
                                </p>
                            </div>
                        </div>
                    </div>
                </div>

                <!-- Issue 3 -->
                <div class="bg-white p-6 rounded-xl shadow-md">
                    <h3 class="text-2xl font-semibold mb-4 text-indigo-700">3. 死锁（Deadlocks）</h3>
                    <p class="text-gray-700 mb-4">
                        死锁是指两个或多个线程在执行过程中，因为争夺资源而造成一种互相等待的状态，从而使得线程无法继续执行。
                    </p>
                    <div class="code-block p-4 rounded-lg mb-4">
                        <pre class="text-sm text-gray-200"><code>class A {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            synchronized (lock2) {
                // Critical section
            }
        }
    }

    public void method2() {
        synchronized (lock2) {
            synchronized (lock1) {
                // Critical section
            }
        }
    }
}</code></pre>
                    </div>
                    <p class="text-gray-600 mb-4">
                        在上述示例中，如果一个线程调用<code>method1()</code>，另一个线程调用<code>method2()</code>，可能会导致两个线程互相等待，形成死锁。
                    </p>
                    <div class="highlight-box p-4 rounded-lg">
                        <h4 class="font-medium text-gray-800 mb-2">解决方法：</h4>
                        <div class="grid md:grid-cols-3 gap-4">
                            <div>
                                <p class="text-gray-700">
                                    <strong>避免嵌套锁</strong>：尽量避免在一个锁持有者中获取其他锁。
                                </p>
                            </div>
                            <div>
                                <p class="text-gray-700">
                                    <strong>使用时间限制的锁</strong>：如<code>tryLock()</code>方法，尝试在一定时间内获取锁。
                                </p>
                            </div>
                            <div>
                                <p class="text-gray-700">
                                    <strong>锁排序</strong>：制定锁获取顺序规则，确保所有线程按照相同的顺序获取锁，避免循环等待。
                                </p>
                            </div>
                        </div>
                    </div>
                </div>

                <!-- Issue 4 -->
                <div class="bg-white p-6 rounded-xl shadow-md">
                    <h3 class="text-2xl font-semibold mb-4 text-indigo-700">4. 活锁（Livelocks）</h3>
                    <p class="text-gray-700 mb-4">
                        活锁是指线程不断地尝试某个操作，但是由于不断地被其他线程干扰而无法完成操作，线程的状态不断变化，但没有实际进展。
                    </p>
                    <div class="code-block p-4 rounded-lg mb-4">
                        <pre class="text-sm text-gray-200"><code>class ActiveObject {
    private boolean flag = false;

    public void method1() {
        while (flag) {
            // Perform some action
        }
    }

    public void method2() {
        while (!flag) {
            flag = true;
            // Attempt to resolve conflict
        }
    }
}</code></pre>
                    </div>
                    <p class="text-gray-600 mb-4">
                        在此示例中，<code>method1()</code>和<code>method2()</code>可能互相影响，导致活锁。
                    </p>
                    <div class="highlight-box p-4 rounded-lg">
                        <h4 class="font-medium text-gray-800 mb-2">解决方法：</h4>
                        <div class="grid md:grid-cols-2 gap-4">
                            <div>
                                <p class="text-gray-700">
                                    <strong>引入退避机制</strong>：在处理冲突时，尝试增加延迟或随机等待时间。
                                </p>
                            </div>
                            <div>
                                <p class="text-gray-700">
                                    <strong>增加锁策略</strong>：使用不同的策略来处理竞争资源的问题。
                                </p>
                            </div>
                        </div>
                    </div>
                </div>

                <!-- Issue 5 -->
                <div class="bg-white p-6 rounded-xl shadow-md">
                    <h3 class="text-2xl font-semibold mb-4 text-indigo-700">5. 可见性问题</h3>
                    <p class="text-gray-700 mb-4">
                        可见性问题发生在一个线程对共享变量的修改，其他线程无法立即看到这些修改。
                    </p>
                    <div class="code-block p-4 rounded-lg mb-4">
                        <pre class="text-sm text-gray-200"><code>class VisibilityExample {
    private boolean flag = false;

    public void method1() {
        flag = true;
    }

    public void method2() {
        if (flag) {
            // Do something
        }
    }
}</code></pre>
                    </div>
                    <p class="text-gray-600 mb-4">
                        在上述示例中，<code>method2()</code>可能无法立即看到<code>method1()</code>中的<code>flag</code>的修改。
                    </p>
                    <div class="highlight-box p-4 rounded-lg">
                        <h4 class="font-medium text-gray-800 mb-2">解决方法：</h4>
                        <div class="grid md:grid-cols-2 gap-4">
                            <div>
                                <p class="text-gray-700">
                                    <strong>使用<code>volatile</code>关键字</strong>：确保对变量的写操作对所有线程立即可见。
                                </p>
                            </div>
                            <div>
                                <p class="text-gray-700">
                                    <strong>使用同步机制</strong>：通过<code>synchronized</code>块来确保变量的可见性。
                                </p>
                            </div>
                        </div>
                    </div>
                </div>

                <!-- Issue 6 -->
                <div class="bg-white p-6 rounded-xl shadow-md">
                    <h3 class="text-2xl font-semibold mb-4 text-indigo-700">6. 线程安全的数据结构</h3>
                    <p class="text-gray-700 mb-4">
                        使用线程安全的数据结构可以避免常见的线程安全问题，这些数据结构在设计时已考虑到多线程环境。
                    </p>
                    <div class="mb-4">
                        <p class="text-gray-600 mb-2"><strong>示例：</strong></p>
                        <ul class="list-disc list-inside text-gray-600 mb-4">
                            <li><code>ConcurrentHashMap</code>：提供高效的线程安全键值对存储。</li>
                            <li><code>BlockingQueue</code>：用于生产者-消费者模式，支持线程安全的队列操作。</li>
                        </ul>
                    </div>
                    <div class="highlight-box p-4 rounded-lg">
                        <h4 class="font-medium text-gray-800 mb-2">解决方法：</h4>
                        <p class="text-gray-700">
                            <strong>使用<code>java.util.concurrent</code>包中的线程安全数据结构</strong>：这些数据结构提供了内建的线程安全性，适用于多线程环境。
                        </p>
                    </div>
                </div>
            </div>
        </section>

        <div class="section-divider my-12"></div>

        <!-- Use Cases Section -->
        <section class="mb-16">
            <h2 class="noto-serif text-3xl font-bold mb-8 text-gray-900">
                <span class="gradient-text">常见的父子线程数据传递场景</span>
            </h2>
            <p class="text-lg text-gray-700 mb-8">
                在多线程编程中，父线程和子线程之间的数据传递是一个常见的需求。以下是一些常见的父子线程数据传递场景，以及如何在这些场景中有效地进行数据传递。
            </p>

            <div class="grid md:grid-cols-2 gap-8">
                <!-- Scenario 1 -->
                <div class="card bg-white p-6 rounded-xl shadow-md">
                    <h3 class="text-xl font-bold mb-4 text-indigo-700 flex items-center">
                        <i class="fas fa-tasks text-indigo-500 mr-3"></i>1. 任务分发与结果收集
                    </h3>
                    <p class="text-gray-700 mb-4">
                        <strong>场景：</strong><br>
                        一个父线程负责将多个任务分发给子线程处理，每个子线程完成任务后将结果返回给父线程。例如，在一个数据处理应用中，父线程将数据分割成多个子任务，分配给子线程进行并行处理，最终收集处理结果。
                    </p>
                    <div class="highlight-box p-4 rounded-lg">
                        <h4 class="font-medium text-gray-800 mb-2">数据传递方式：</h4>
                        <ul class="list-disc list-inside text-gray-700 space-y-2">
                            <li><strong>共享数据结构</strong>：父线程和子线程可以通过共享数据结构（如<code>ConcurrentLinkedQueue</code>）进行结果传递。</li>
                            <li><strong><code>Future</code>与<code>Callable</code></strong>：使用<code>Future</code>和<code>Callable</code>接口，子线程通过<code>Callable</code>返回结果，父线程通过<code>Future</code>获取结果。</li>
                            <li><strong><code>BlockingQueue</code></strong>：父线程将任务放入<code>BlockingQueue</code>，子线程从队列中获取任务并处理，处理结果也可以放入另一个<code>BlockingQueue</code>供父线程读取。</li>
                        </ul>
                    </div>
                    <div class="mt-4 code-block p-4 rounded-lg">
                        <pre class="text-sm text-gray-200"><code>import java.util.concurrent.*;

public class TaskDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        Future&lt;String&gt; future1 = executor.submit(() -&gt; "Task 1 result");
        Future&lt;String&gt; future2 = executor.submit(() -&gt; "Task 2 result");

        System.out.println("Result from Task 1: " + future1.get());
        System.out.println("Result from Task 2: " + future2.get());

        executor.shutdown();
    }
}</code></pre>
                    </div>
                </div>

                <!-- Scenario 2 -->
                <div class="card bg-white p-6 rounded-xl shadow-md">
                    <h3 class="text-xl font-bold mb-4 text-indigo-700 flex items-center">
                        <i class="fas fa-cog text-indigo-500 mr-3"></i>2. 父线程设置共享数据
                    </h3>
                    <p class="text-gray-700 mb-4">
                        <strong>场景：</strong><br>
                        父线程在启动子线程之前需要设置共享数据，以供所有子线程访问。例如，在一个分布式计算应用中，父线程设置全局配置或共享资源，所有子线程需要读取这些配置或资源进行计算。
                    </p>
                    <div class="highlight-box p-4 rounded-lg">
                        <h4 class="font-medium text-gray-800 mb-2">数据传递方式：</h4>
                        <ul class="list-disc list-inside text-gray-700 space-y-2">
                            <li><strong>共享变量</strong>：将共享数据保存在父线程创建的共享变量中。所有子线程通过访问这些共享变量获取数据。</li>
                            <li><strong><code>ThreadLocal</code></strong>：对于每个线程需要独立数据的情况，父线程可以使用<code>ThreadLocal</code>来设置每个线程的局部数据。</li>
                        </ul>
                    </div>
                    <div class="mt-4 code-block p-4 rounded-lg">
                        <pre class="text-sm text-gray-200"><code>public class SharedDataDemo {
    private static String sharedData = "Shared Data";

    public static void main(String[] args) {
        Runnable task = () -&gt; {
            System.out.println("Accessing shared data: " + sharedData);
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);

        thread1.start();
        thread2.start();
    }
}</code></pre>
                    </div>
                </div>

                <!-- Scenario 3 -->
                <div class="card bg-white p-6 rounded-xl shadow-md">
                    <h3 class="text-xl font-bold mb-4 text-indigo-700 flex items-center">
                        <i class="fas fa-chart-line text-indigo-500 mr-3"></i>3. 子线程的进度更新
                    </h3>
                    <p class="text-gray-700 mb-4">
                        <strong>场景：</strong><br>
                        父线程需要跟踪子线程的进度。例如，在文件下载应用中，父线程需要定期获取子线程的下载进度，并更新用户界面。
                    </p>
                    <div class="highlight-box p-4 rounded-lg">
                        <h4 class="font-medium text-gray-800 mb-2">数据传递方式：</h4>
                        <ul class="list-disc list-inside text-gray-700 space-y-2">
                            <li><strong>回调机制</strong>：子线程通过回调方法将进度信息传递给父线程。父线程可以实现一个接口，并将其作为参数传递给子线程。</li>
                            <li><strong>共享对象</strong>：子线程定期更新一个共享对象中的进度信息，父线程可以定期检查这个对象的状态。</li>
                        </ul>
                    </div>
                    <div class="mt-4 code-block p-4 rounded-lg">
                        <pre class="text-sm text-gray-200"><code>import java.util.concurrent.atomic.AtomicInteger;

public class ProgressUpdateDemo {
    private static AtomicInteger progress = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -&gt; {
            for (int i = 0; i <= 100; i += 10) {
                progress.set(i);
                try {
                    Thread.sleep(500); // Simulate work
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        };

        Thread worker = new Thread(task);
        worker.start();

        while (progress.get() < 100) {
            System.out.println("Progress: " + progress.get() + "%");
            Thread.sleep(200); // Polling interval
        }
    }
}</code></pre>
                    </div>
                </div>

                <!-- Scenario 4 -->
                <div class="card bg-white p-6 rounded-xl shadow-md">
                    <h3 class="text-xl font-bold mb-4 text-indigo-700 flex items-center">
                        <i class="fas fa-sliders-h text-indigo-500 mr-3"></i>4. 父线程控制子线程的行为
                    </h3>
                    <p class="text-gray-700 mb-4">
                        <strong>场景：</strong><br>
                        父线程需要通过控制信号来影响子线程的行为。例如，父线程可以发出停止信号，让子线程停止其执行。
                    </p>
                    <div class="highlight-box p-4 rounded-lg">
                        <h4 class="font-medium text-gray-800 mb-2">数据传递方式：</h4>
                        <ul class="list-disc list-inside text-gray-700 space-y-2">
                            <li><strong>共享控制变量</strong>：使用共享变量（如<code>volatile</code>变量）来控制子线程的执行状态。子线程在运行时定期检查这些控制变量的值，以决定是否继续执行。</li>
                            <li><strong><code>CountDownLatch</code></strong>：使用<code>CountDownLatch</code>来协调子线程的启动或停止。父线程通过调用<code>countDown()</code>方法来通知子线程。</li>
                        </ul>
                    </div>
                    <div class="mt-4 code-block p-4 rounded-lg">
                        <pre class="text-sm text-gray-200"><code>import java.util.concurrent.CountDownLatch;

public class ControlDemo{
    private static volatile boolean stopRequested = false;

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(1);

        Runnable task = () -&gt; {
            while (!stopRequested) {
                System.out.println("Working...");
                try {
                    Thread.sleep(500); // Simulate work
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            System.out.println("Stopped.");
        };

        Thread worker = new Thread(task);
        worker.start();

        // Simulate work
        Thread.sleep(2000);

        // Request stop
        stopRequested = true;
        latch.countDown();
        worker.join();
    }
}</code></pre>
                    </div>
                </div>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-gray-900 text-white py-8 px-4 sm:px-6 lg:px-8">
        <div class="max-w-5xl mx-auto text-center">
            <div class="flex flex-col items-center justify-center">
                <h3 class="text-xl font-bold mb-2">技术小馆</h3>
                <a href="http://www.yuque.com/jtostring" class="text-gray-300 hover:text-white transition duration-300">
                    http://www.yuque.com/jtostring
                </a>
            </div>
            <div class="mt-6 pt-6 border-t border-gray-800 text-sm text-gray-400">
                &copy; 2024 技术小馆. 保留所有权利.
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```